Si l'extension Initialization cells est activée, vous devez "Faire Confiance" (Trust) le Notebook.
Ensuite vous devez attendre l'exécution de ses cellules (de code ;)). (Il y aura 1 (2) alerte(s) si l'initialisation c'est bien passée, sinon soit l'extension ne marche pas, soit bug dans le code )

In [ ]:
from IPython.core.display import display, HTML
display(HTML("<style>.container { width:100% !important }</style>"))
Le Coronavirus: Covid 19

Qu'est ce que le Covid-19 (Intro)

Qu'est ce qu'un Virus

Etymologie

Le mot "Virus" est un mot venant du latin et qui signifie : poison, toxine

Histoire

Au 19e siècle, une maladie touche les feuilles de tabac : la mosaïque du tabac
En 1892, Dimitri Iwanowski (un biologiste russe) tente de filtrer, de cette maladie, la sève de feuille de tabac au moyen de la bougie de Chamberland. Les bactéries sont filtrés, mais un micro-organisme ( un agent infectieux) ne l'est pas.
Il fera l'hypothèse que ce micro-organisme était une toute petite bacterie, ou une toxine.

Plus tard vers les années 1930, avec l'arrivé de microscope électronique, les virus pourront enfin isolés (rougeole, la rubéole, la varicelle, et plus tard le sida).

Maladie de la Mosaïque du Tabac Bougie de Chamberland pour le filtrage</span>

Définition

En 1953, André LWOFF énonce les trois caractères fondamentaux d'un virus :

  • le virus ne contient qu’un seul type d’acide nucléique (ADN ou ARN) qui constitue le génome viral.
  • le virus se reproduit à partir de leur matériel génétique et par réplication.
  • le virus est doué de parasitisme intracellulaire absolu.

« Agent responsable d'une maladie infectieuse, parasite, de nature particulaire et de taille comprise entre 0,01 et 0,3 micromètre "

"Ils ne peuvent se reproduire qu’au sein de cellules vivantes, ne possédant aucun système d’énergie, ils détournent la machinerie cellulaire à leur profit pour se répliquer et assurer leur pérennité."
"Ils constituent en quelque sorte des structures extrêmement simples dont l’ensemble des éléments protège quelques petits bouts de code génétique ayant pour objectifs de s’infiltrer dans une cellule pour la parasiter, puis la détruire."

"En définitive, à l’aide de quelques gènes, les virus peuvent altérer et modifier les programmes de fonctions intracellulaires à leur profit, avec pour objectif final de transformer l’organisme infecté en agent contaminant, capable de propager l’infection et d’assurer la survie du virus."

(http://www.microbes-edu.org/etudiant/virus.html)

Structure

Les virus sont des organismes composés d'une enveloppe de protéines laquelle renferme de l'ADN ou de l'ARN , ils n'ont pas de métabolisme et ne peuvent pas se reproduire. Ils doivent pour cela pénétrer nos cellules, en prendre le contrôle et en détourner le métabolisme à leur profit. C'est ainsi que les virus se répliquent et disséminent dans tout notre corps. Pour passer d'une personne à l'autre, les virus empruntent différentes voies. Certains virus utilisent la voie respiratoire, d'autres la voie digestive, transcutanée ou encore sexuelle. Les virus peuvent infecter tous les organismes, humains, animaux, végétaux. Ils peuvent aussi infecter les bactéries.

Propagation du virus dans le corps

Un humain infecté parle à un autre humain, lorsqu'il va parler des goutelettes de salives vont arrivé sur l'autre humail

Un fois dans le corps, le virus va tenter de rentrer dans un cellule à l'aide de ses spicules quie se lie à la membrane de celle ci

Une fois dans la cellule le génome du virus s'insère dans l'adn de la cellule.

Ensuite ce génome est lu par la cellule et est repliqué, ce qui fabrique d'autre virus qui vont ensuite sortir de la cellule pour en infecter d'autres.

La cellule infecté va ensuite fabriquer d'autres virus jusqu'à sa mort

Résumé en une image

Combattre les virus

Pour combattre les virus, il existe plusieurs possibilités. On peut limiter la transmission en réduisant les contacts ou donner des médicaments qui tentent de bloquer l'entrée du virus dans les cellules ou sa multiplication. Le Vaccin

Qu'est ce qu'un Coronavirus (WIP)

Les Coronavirus (CoV) forment une immense famille de virus possédant un génome à ARN extrêmement long (plusieurs milliers de nucléotides ). Ils sont entourés d’une capsule de protéines en forme de couronne qui leur vaut leur nom.

Syndrome respiratoire aigu sévère (SRAS)

Le SRAS-CoV est le premier coronavirus qui a entrainé une maladie grave chez l’Homme. Il a sévi sous forme épidémique entre novembre 2002 et juillet 2003. Plus de 8 000 cas ont été recensés dans 30 pays (dont près de 20% chez des soignants) et 774 personnes sont décédées (soit près de 10% de mortalité).

L’épidémie est partie de quelques cas dans la province du Guangdong, en Chine du Sud-Est, suite à la consommation de viande de civette infectée.

Le MERS

Les Epidemies, Endémies et Pandemies à travers l'histoire

Qu'est ce qu'une epidémie

Une épidémie correspond à l'apparition intermittente, mais rapide, d'une maladie infectieuse et contagieuse.
Elle touche un groupe de population de façon plus ou moins importante, dans une région donnée.
Ex : grippe hivernale, ebola

Qu'est ce qu'une endémie

Au contraire de l'épidémie qui apparaît de manière saisonnière, par pics, l'endémie persiste dans une même région de manière habituelle.
Ex : paludisme, fièvre jaune

Qu'est ce qu'une pandemie

Comme pour l'épidémie, la pandémie apparaît brutalement et en plus, elle sévit à l'échelle d'une zone géographique très étendue, à l'occasion de l'émergence d'un nouveau virus.

Source

Timeline

Épidemiologie

Zoonoses

Les zoonoses sont des maladies ou infections qui se transmettent des animaux vertébrés à l'homme, et vice versa. Les pathogènes en cause peuvent être des bactéries, des virus ou des parasites. La transmission de ces maladies se fait soit directement, lors d'un contact entre un animal et un être humain, soit indirectement par voie alimentaire ou par l’intermédiaire d'un vecteur (insecte, arachnides…). D'après l'Organisation mondiale de la santé animale, 60% des maladies infectieuses humaines sont zoonotiques.

Maladie virale, bactérienne ou parasitaire animale, capable d'infecter l'Homme suite à une mutation.

Le Réservoir, L'Hôte Intermédiaire et l'Homme

Explication des termes (Intro)

Distinction entre : "Contaminé", "Depisté", "Gueri", "Décès", "Hospitalisé", "Reanimation"

Comtaminé :
/!\ Tous les comtaminé ne sont pas recensensé
/!\ Ils ne sont pas comptabilisé de façon homogène dans tout les pays.
Depisté :
/!\ Tous les comtaminé ne sont pas recensensé
Gueri :
/!\ sorties de l'hôpital
Déces :
/!\ Ils ne sont pas comptabilisé de façon homogène dans tout les pays
Hospitalisé :
/!\ A l'Hopital ?
Réanimation :
/!\ En réanimation

Distinction entre cas réel et cas testé (WIP)

"Soins critiques" distinction entre : "Unité de soins intensif", "Unités de réanimation", "SURVEILLANCE CONTINUE"

"Ces trois expressions désignent des soins destinés à prévenir les défaillances organiques potentielles et à traiter les défaillances avérées."

La réanimation (soins critique) est organisée en trois paliers :

  • Unité de Soins (Surveillance) Continus (USC),
  • Unité de Soins Intensifs (USI),
  • Service de réanimation (réa)

Unité de Soins intensif (USI) :
Structure médiane entre le service de réanimation et l’unité de soins continus (USC).
Elle prend en charge une défaillance unique sur une durée limitée
L'intermédiaire entre la réanimation et les services de soins généraux hospitaliers.

Unité de Soins (Surveillance) Continus (USC) :
Elle prend en charge les patients dont l'état, au sortir d'une ou plusieurs défaillances vitales est trop sévère ou instable pour permettre un retour dans une unité d'hospitalisation classique

Service de réanimation (réa) :
Il prend en charge des défaillances multiples sur une durée prolongée.

La propagation de l'épidémie Covid-19 en pandemie (Intro)

Timeline qui va être expliqué dans cette section

image.png

Les barres oranges représentes les cas diagnostiqué, et les grises les cas réels.

Hubei

Le Marché de Huanan à Wuhan

image.png

Le marché de Huanan est un marché de fruits de mer et d'autres animaux vivants.
Le marché, situé à quelques pâtés de maisons de la gare de Hankou, 3e gare ferroviaire la plus importante de Wuhan (+10 000), occupe plus de 50 000 m2 et abrite plus de 1 000 commerçants. C'est le plus grand marché de gros de fruits de mer à Wuhan et en Chine centrale

On y vend notamment:

  • des mammifères (porc, chameau, mouton, cerf, kangourou, lapin, castor, rat, porc-épic, marmotte, blaireau, loutre, civette*, chien, renard, louveteaux, hérisson)
  • des oiseaux (volaille, autruche, paon, faisan)
  • des reptiles (crocodile, tortue, divers serpents y compris bungarus multicinctus)
  • des amphibiens (grenouilles, salamandre géante), des arthropodes (cigale, scorpion, scolopendre)

*J'ai mis la civette en gras pour rappeller que la sars-cov 1 avait eu comme hôte intermédiaire la civette.

Pendant le mois de Novembre-Décembre, plusieurs cas de pneumonies inabituels ont survenues qui ne réagissait pas aux traitements habituel. Les patients avaient comme point commun le marché de Huanan, ce qui a conduit a sa fermeture le 1er janvier.
Au même moment une alerte a été OMS notifié par le gouvernement chinois (“The disease is preventable and controllable...”).

D'apres le graphique, le nombre de cas réel était au 1er janvier de ~100.

On a découvert ensuite, que l'un des premiers patient en chine présentant le coronavirus, est arrivé le 17 Novembre.
En simulant l'épidémie, on arrive aussi à ~250 cas au 1er janvier. (donc 44 jours plus tard) (R0=2.5)

En ordre de grandeur des centaines.

La découverte du 2019-nCoV et du Covid19 (Sars-cov-2)

Le 9 janvier 2020, les autorités sanitaires chinoises et l’Organisation mondiale de la santé (OMS) annoncent la découverte d’un nouveau coronavirus, appelé 2019-nCoV, et présenté comme l’agent responsable de ces pneumonies.

Les autorités chinoises partagent, dès le week-end du 11-12 janvier, la séquence complète du génome du coronavirus qu’ils ont détecté dans des échantillons prélevés sur leurs premiers patients.

Le confinement du Wuhan puis de Hubei

C'est le 23 Janvier que Wuhan est confiné et le 24 que 15 autres ville du hubein qui le sont.
Le 24 les cas diagnostiqués sont au nombre de ~600, alors qu'en réalité, il y a ~10 000.

En simulant on arrive au 24 Janvier (67 jours après le 1er cas) : ~10 000. (avec un R0 de 2.5)

Cas de coronavarirus dans le pays au 24 Janvier.

On voit qu'il y a beaucoup de cas à Wuhan et plus généralement dans le Hubei, et quelque cas à Beijing, Shenzen, Shanghai.

En ordre de grandeur des dizaines de milliers

La Propagation dans le pays

Au 4 février d'aprés les cas diagnostiqué, il y avait ~20 000 cas alors qu'en cas réel il y avait ~40 000 cas

En simulant: ~40 000 cas aussi (+ 80 jours) (R0=2.5)

La progagation dans le monde (WIP)

Set Up (Tech)

SI DANS LE DOCKER -> les cells d'initialisation ont été exécutées, si pas éxécuté appuyer sur le bouton calculatrice

Les imports

Packages

In [ ]:
#!pip install moment git+http://github.com/lucasiscovici/studyProject.git dill
Collecting git+http://github.com/lucasiscovici/studyProject.git
  Cloning http://github.com/lucasiscovici/studyProject.git to /tmp/pip-req-build-klcdzzi8
  Running command git clone -q http://github.com/lucasiscovici/studyProject.git /tmp/pip-req-build-klcdzzi8
Collecting moment
  Downloading moment-0.8.2.tar.gz (4.7 kB)
Requirement already satisfied: dill in /opt/conda/lib/python3.7/site-packages (0.3.1.1)
Collecting scikit-learn==0.20.3
  Downloading scikit_learn-0.20.3-cp37-cp37m-manylinux1_x86_64.whl (5.4 MB)
     |████████████████████████████████| 5.4 MB 640 kB/s eta 0:00:01     |███████████████████             | 3.2 MB 452 kB/s eta 0:00:05     |██████████████████████████      | 4.4 MB 49 kB/s eta 0:00:21     |██████████████████████████▉     | 4.5 MB 49 kB/s eta 0:00:18     |███████████████████████████     | 4.5 MB 49 kB/s eta 0:00:17
Collecting version_parser==1.0.0
  Downloading version_parser-1.0.0.tar.gz (4.4 kB)
Collecting numpy==1.17.4
  Downloading numpy-1.17.4-cp37-cp37m-manylinux1_x86_64.whl (20.0 MB)
     |████████████████████████████████| 20.0 MB 569 kB/s eta 0:00:01    |███████▋                        | 4.7 MB 1.7 MB/s eta 0:00:09     |██████████████▉                 | 9.3 MB 1.5 MB/s eta 0:00:08     |███████████████                 | 9.4 MB 1.5 MB/s eta 0:00:08     |██████████████████████████████▎ | 18.9 MB 1.0 MB/s eta 0:00:02
Collecting python-interface==1.5.1
  Downloading python-interface-1.5.1.tar.gz (14 kB)
Collecting cufflinks-study@ git+git://github.com/lucasiscovici/cufflinks#egg=cufflinks_study
  Cloning git://github.com/lucasiscovici/cufflinks to /tmp/pip-install-g10p9_8e/cufflinks-study
  Running command git clone -q git://github.com/lucasiscovici/cufflinks /tmp/pip-install-g10p9_8e/cufflinks-study
Collecting plotly-study@ git+git://github.com/lucasiscovici/plotly_py#egg=plotly_study
  Cloning git://github.com/lucasiscovici/plotly_py to /tmp/pip-install-g10p9_8e/plotly-study
  Running command git clone -q git://github.com/lucasiscovici/plotly_py /tmp/pip-install-g10p9_8e/plotly-study
Collecting cvopt-study@ git+git://github.com/lucasiscovici/cvopt#egg=cvopt_study
  Cloning git://github.com/lucasiscovici/cvopt to /tmp/pip-install-g10p9_8e/cvopt-study
  Running command git clone -q git://github.com/lucasiscovici/cvopt /tmp/pip-install-g10p9_8e/cvopt-study
Collecting mpld3_study@ git+git://github.com/lucasiscovici/mpld3_study#egg=mpld3_study
  Cloning git://github.com/lucasiscovici/mpld3_study to /tmp/pip-install-g10p9_8e/mpld3-study
  Running command git clone -q git://github.com/lucasiscovici/mpld3_study /tmp/pip-install-g10p9_8e/mpld3-study
  Running command git submodule update --init --recursive -q
Collecting speedml_study@ git+git://github.com/lucasiscovici/speedml_study#egg=speedml_study
  Cloning git://github.com/lucasiscovici/speedml_study to /tmp/pip-install-g10p9_8e/speedml-study
  Running command git clone -q git://github.com/lucasiscovici/speedml_study /tmp/pip-install-g10p9_8e/speedml-study
Collecting dora_study@ git+git://github.com/lucasiscovici/Dora_study#egg=dora_study
  Cloning git://github.com/lucasiscovici/Dora_study to /tmp/pip-install-g10p9_8e/dora-study
  Running command git clone -q git://github.com/lucasiscovici/Dora_study /tmp/pip-install-g10p9_8e/dora-study
Collecting studyPipe@ git+git://github.com/lucasiscovici/studyPipe#egg=studyPipe
  Cloning git://github.com/lucasiscovici/studyPipe to /tmp/pip-install-g10p9_8e/studyPipe
  Running command git clone -q git://github.com/lucasiscovici/studyPipe /tmp/pip-install-g10p9_8e/studyPipe
Collecting snakeviz-study@ git+git://github.com/lucasiscovici/snakeviz2#egg=snakeviz_study
  Cloning git://github.com/lucasiscovici/snakeviz2 to /tmp/pip-install-g10p9_8e/snakeviz-study
  Running command git clone -q git://github.com/lucasiscovici/snakeviz2 /tmp/pip-install-g10p9_8e/snakeviz-study
Collecting pandas-profiling-study@ git+git://github.com/lucasiscovici/pandas-profiling-study#egg=pandas_profiling_study
  Cloning git://github.com/lucasiscovici/pandas-profiling-study to /tmp/pip-install-g10p9_8e/pandas-profiling-study
  Running command git clone -q git://github.com/lucasiscovici/pandas-profiling-study /tmp/pip-install-g10p9_8e/pandas-profiling-study
In [38]:
from IPython.display import clear_output
from IPython import display

import logging
import collections
import os
import sys
import math
from dfply import make_symbolic

from datetime import datetime, date
import moment as moment_

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

from studyProject.utils import *
from studyProject.helpers import *

from studyProject import Datas, StudyProject, StudyClassif
from studyProject.study.studyClassif import DatasClassif
from studyProject.utils.speedMLNewMethods import Speedml3

from studyPipe.studyPipe import convert_pipe, Pipe

# Graph Library
import plotly_study.graph_objs as go
import plotly.graph_objs as go2
import cufflinks_study as cf
import plotly.express as px
import plotly.offline as poff


#import dash
#from dash.dependencies import Input, Output
#import dash_html_components as html
#import dash_core_components as dcc

#import werkzeug,logging


#logging.getLogger('werkzeug').setLevel(logging.ERROR)
config_completer()
cf.go_offline()

R (Si utilisé plus tard)

In [571]:
import rpy2
from rpy2.robjects.packages import importr
from rpy2.robjects.vectors import StrVector
_=utils.chooseCRANmirror(ind=25) 
from rpy2.robjects import pandas2ri
pandas2ri.activate()
import rpy2.ipython.html
rpy2.ipython.html.init_printing()
%load_ext rpy2.ipython
The rpy2.ipython extension is already loaded. To reload it, use:
  %reload_ext rpy2.ipython

Functions

In [20]:
#Execute this codeCell to Execute all Functions

all Functions

add To nb

In [2]:
display_html("""<script>
$('[data-name="Aucun(e)"]').on("click",Jupyter.CellToolbar.global_hide)
</script>""")

utils python

In [3]:
# switch operator
# switch(choice: Dictionary, defaultValue: Any)
#
# EX: switch( {"foo": 10, "bar": 100 }, 0) 
def switch(switcher,default=""):
    return lambda argument: switcher.get(argument, default)

class _hideLog:
    def __enter__(self):
        self.curr=logging.getLogger().level
        logging.getLogger().setLevel(logging.CRITICAL)
        return self
    def __exit__(self,*args,**xargs):
        logging.getLogger().setLevel(self.curr)
hideLog=_hideLog()

Functions to get all datas

In [4]:
# get world data about confirmed and deaths
def getData(force=False,
            silent=False):
    
    def _getDataByValue(url=None,value=None,force=False,silent=False):
        today = date.today()
        fname="data/covid_19_data_{}_times_{}.csv".format(value, today.strftime("%Y_%m_%d"))
        
        if silent: return os.path.isfile(fname)
        
        if not os.path.isfile(fname) or force:
            print(f"load data {value}...")
            os.system(f"curl {url} > data/_covid_19_data_times2.csv")
            dataImported=pd.read_csv("data/_covid_19_data_times2.csv")
            dataColumns=(dataImported >> df.select(~df.columns_to("Long",inclusive=True))).columns
            dataWide=dataImported >> df.gather('Date', value, dataColumns)
            dataWide.columns=dataWide.columns.map(lambda a:a.replace("/","_"))
            dataWide.to_csv(fname,index=False)
        else:
            dataWide=pd.read_csv(fname)
            
        return dataWide
    
    if silent:
        return _getDataByValue(value="Deaths",silent=True)

    (deaths, confirmed)= [
                    _getDataByValue("https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_deaths_global.csv",
                             "Deaths",
                             force),
                    _getDataByValue("https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_confirmed_global.csv",
                             "Confirmed",
                             force)
                    ]
    
    allDataCovid=deaths >> df.inner_join(confirmed,
                                by=["Province_State",
                                    "Country_Region",
                                    "Lat",
                                    "Long",
                                    "Date"])
    
    if not (deaths.shape[0] == confirmed.shape[0] and confirmed.shape[0] == allDataCovid.shape[0]): 
        print("ERROR: /!\ pb de join",deaths,confirmed,allDataCovid)
        return None
    
    return allDataCovid

# NOT NEEDED NOW
# get French Data about confirmed and deaths
def getDataFr(force=False,
              silent=False):
    return True
    today = date.today()
    fname="data/chiffres-cles_{}.csv".format(today.strftime("%Y_%m_%d"))    
    
    if silent:
        return os.path.isfile(fname)
    
    if not os.path.isfile(fname) or force:
        print("load data fr...")
        dirTmp=TMP_DIR()
        os.system("git clone https://github.com/opencovid19-fr/data.git "+dirTmp.get())
        os.system("cp -r {dirTmp.i} /sante-publique-france covidD/")
        dirTmp.delete()
        os.system("cd covidD && node build")
        frData = pd.read_csv("covidD/dist/chiffres-cles.csv")
        frData=frData >> df.filter_by(X.granularite=="pays") >> df.select("date",df.columns_between(X.cas_confirmes,X.gueris))
        frData.to_csv(fname,index=False)
    else:
        frData=pd.read_csv(fname)

    return frData
In [5]:
# get population by country with population by age 
def getDataPopu(fname="./data/popu.csv", force=False, silent=False):
    
    if silent:
        return os.path.isfile(fname)
    
    if force or not os.path.isfile(fname):
        popu=(
                pd.read_csv("./data/WPP2019_POP_F15_1_ANNUAL_POPULATION_BY_AGE_BOTH_SEXES/ESTIMATES-Tableau 1.csv",
                         ";",
                         skiprows=range(16))
               .reset_index(drop=T)
            ) >> df.drop(range(2))
        # select right columns
        popuMonde=(popu 
                    >> df.filter_by(X.Type=="Country/Area",
                                    X.iloc[:,5]==2020) 
                    >> df.select(0,df.columns_from(6)) 
                    >> df.rename(pays=0)) | __.reset_index(drop=True)  
        # group in tranche A (0-14), B (15-44), C (45-64), D (65-74), E (75-+)
        popuMonde["Code tranches d'age_A"]=popuMonde.loc[:,['0-4', '5-9', '10-14']].transform(lambda a:a.str.replace(" ","").astype(int)).sum(axis=1)
        popuMonde["Code tranches d'age_B"]=popuMonde.loc[:,['15-19','20-24','25-29','30-34','35-39','40-44']].transform(lambda a:a.str.replace(" ","").astype(int)).sum(axis=1)
        popuMonde["Code tranches d'age_C"]=popuMonde.loc[:,['45-49','50-54','55-59','60-64']].transform(lambda a:a.str.replace(" ","").astype(int)).sum(axis=1)
        popuMonde["Code tranches d'age_D"]=popuMonde.loc[:,['65-69','70-74']].transform(lambda a:a.str.replace(" ","").astype(int)).sum(axis=1)
        popuMonde["Code tranches d'age_E"]=popuMonde.loc[:,['75-79','80-84','85-89','90-94','95-99','100+']].transform(lambda a:a.str.replace(" ","").astype(int)).sum(axis=1)
        popuMonde=popuMonde.drop(['0-4', '5-9', '10-14'],axis=1)
        popuMonde=popuMonde.drop(['15-19','20-24','25-29','30-34','35-39','40-44'],axis=1)
        popuMonde=popuMonde.drop(['45-49','50-54','55-59','60-64'],axis=1)
        popuMonde=popuMonde.drop(['65-69','70-74'],axis=1)
        popuMonde=popuMonde.drop(['75-79','80-84','85-89','90-94','95-99','100+'],axis=1)
        
        # long -> wide
        popuMondeTranches=(
            (popuMonde >> df.mutate( popu = X.iloc[:,1:].sum(axis=1) ) >> df.gather("tranches_age","value", df.starts_with("Code"))) >> 
             df.mutate(tranches_age=X.tranches_age.str.replace("Code tranches d'age_",""))
        )
        popuMondeTranches.to_csv(fname,index=False)
    else:
        popuMondeTranches=pd.read_csv(fname)
    return popuMondeTranches
In [6]:
# get life expectancy 
def getDataLife(fname="./data/life_expectancy.csv",force=False,silent=False):
    if silent:
        return os.path.isfile(fname)
    lifeExp=pd.read_csv(fname,
           sep=";")
    lifeExpBothSexes=((lifeExp.set_index(lifeExp
                                         .columns[:2]
                                         .tolist()
                                        ) >> 
                      df.select( ~df.contains(".") )) |__
                      .drop("Country") |__
                      .loc[(slice(None),"2016"),:] |__
                      .reset_index(1,drop=T) |__
                      .rename_axis("Country")
                     ).reset_index()
    return lifeExpBothSexes.set_index("Country").astype("float").reset_index()


def getDataDoctors(fname="./data/doctorsWorld.csv", force=False, silent=False):
    if silent:
        return os.path.isfile(fname)
    medicalWorld=(pd.read_csv("./data/medicalWorld.csv",
                          index_col=[0,1])
                    .iloc[:,:1]
                    .drop(( 'Country',  'Year'))
                    .rename_axis(( 'Country',  'Year'))
                    .reset_index("Year")
                    .groupby("Country")
                    .first()
                    .reset_index()
                    .dropna()                                                                              |__
                    .astype((__.columns,[np.object,np.int,np.float])                              |_funs_| 
                            zip                                                                   |_fun_| 
                            dict)
                    .rename_cols(__.columns[:2].tolist()+["MedicalDoctorsPer100000"])
                    .mutate(MedicalDoctorsPer100000=X.MedicalDoctorsPer100000*10)
             )
    medicalWorld.to_csv(fname,index=False)
    return medicalWorld

# get hospital beds, acute beds, icu beds (/100000)
def getDataBeds(fname="./data/bedsWorld.csv",force=False,silent=False):
    if silent:
        return os.path.isfile(fname)
    hospitals=(pd.read_csv("data/Hospital_beds_100000.csv")
             .groupby("Country").first().reset_index()
            )
    icuBeds=(pd.read_csv("data/icus.csv",sep=";",usecols=range(3))
                 .groupby("Country").first().reset_index().set_axis(["Country","acuteBeds/100000","icuBeds/100000"],axis=1)
                )
    icuBedsAsia=(pd.read_csv("data/bedsAsia.csv",sep=";",usecols=range(5))
                 .groupby("Country").first().reset_index()
                )
    icuBedAsia2=(
        icuBedsAsia
        .mutate(criticalCareBedsPer100000Verif=(X.criticalCareBeds/X.popu*100000).round(1))
        .mutate(acuteHospitalBed=(X.criticalCareBeds/X.criticalCareBedsAsPercOfAcuteHospitalBeds*100).round(0))
        .mutate(acuteHospitalBedPer100000=(X.acuteHospitalBed/X.popu*100000).round(1))
    ).iloc[:,[0,7,3]].set_axis(['Country', 'acuteBeds/100000', 'icuBeds/100000'],axis=1)

    acuteAndIcuBeds=pd.concat([icuBeds,icuBedAsia2],ignore_index=T)
    hostipalsBeds=hospitals.drop(["Year"],axis=1)
    hostipalsBeds.Country=(hospitals.Country
                                .replace("Brunei Darussalam","Brunei")
                                .replace("Czechia","Czech Republic")
                                .replace("Democratic People's Republic of Korea","North Korea")
                                .replace("Democratic Republic of the Congo","Congo")
                                .replace("Iran (Islamic Republic of)","Iran")
                                .replace("Lao People's Democratic Republic","Laos")
                                .replace("Republic of Korea","South Korea")
                                .replace("United Kingdom of Great Britain and Northern Ireland","UK")
                                .replace("United States of America","USA")
                          )
    acuteAndIcuBeds.Country = (acuteAndIcuBeds.Country
                                  .replace("The Netherlands","Netherlands")
                              )
    beds=hostipalsBeds.merge(acuteAndIcuBeds,how="outer").sort_values("Country")
    beds.to_csv(fname,index=F)
    return beds

Moment

In [7]:
# fonction like moment js 
# use the python library moment
#
# moment() -> Actual date
# moment(2020,3,22) -> get the 22/03/20 Date
# moment(1585602607) -> get the date with timestamp
# moment("today") or moment("22/03/20") -> get the date from string
# moment("03/22/20","%m/%d/%y") -> get the date from string and format
# moment(datetime.date(2019, 4, 13)) -> get the date from datetime object
def moment(*args,utc=False):
    if len(args)==0:
        return moment_.now() if not utc else moment_.utcnow()
    if len(args)==3 and type(args[0]) is int:
        return moment_.date(*args) if not utc else  moment_.utc(*args)
    if len(args)==1 and type(args[0]) in [int,float]:
        return moment_.unix(args[0],utc=utc)
    if len(args)==1 and type(args[0]) is str:
        return moment_.date(args[0]) if not utc else moment_.utc(args[0])
    if len(args)==2 and type(args[0]) is str and type(args[1]) is str:
        return moment_.date(args[0],args[1]) if not utc else moment_.utc(args[0],args[1])
    if len(args)==1 and type(args[0]) is datetime:
        return moment_.date(args[0]) if not utc else moment_.utc(args[0])
    return moment_(*args,utc=utc)
In [477]:
# add the method startOf from moment js 
# 
# .startOf("year") -> get the date startOf year
def startOf (this_,units):
    #units = normalizeUnits(units);
    # the following switch intentionally omits break keywords
    # to utilize falling through the cases.
    this=this_.copy()
    switch ({
        'year':lambda: this.replace(months=1,days=1,hours=0,minutes=0,seconds=0,microseconds=0), #date(1).hours(0).minutes(0).seconds(0).milliseconds(0);
         'quarter':lambda:this.replace(days=1,hours=0,minutes=0,seconds=0,microseconds=0),#hours(0).minutes(0).seconds(0).milliseconds(0);
         'month':lambda:this.replace(days=1,minutes=0,seconds=0,microseconds=0),
         'week':lambda:this.replace(hours=0,minutes=0,seconds=0,microseconds=0),
         'isoWeek':lambda:this.replace(hours=0,minutes=0,seconds=0,microseconds=0),
         'day':lambda:this.replace(hours=0,minutes=0,seconds=0,microseconds=0),
         'date':lambda:this.replace(hours=0,minutes=0,seconds=0,microseconds=0),
         'hour':lambda:this.replace(minutes=0,seconds=0,microseconds=0),
         'minute':lambda:this.replace(seconds=0,microseconds=0),
         'second':lambda:this.replace(microseconds=0)
    })(units)()

    # weeks are a special case
    if (units == 'week'):
        this.replace(weekday=0)
        
    if (units == 'isoWeek'):
        raise NotImplementedError

    # quarters are also special
    if (units == 'quarter'):
        this.replace(months=math.floor(this.month/3)*3)

    return this;
moment_.Moment.startOf=startOf

# add the method endOf from moment js 
# 
# .endOf("year") -> get the date endOf year
def endOf (thisd,units=None):
    this=thisd.copy()
    if (units is None or units == 'millisecond'):
        return this

    # 'date' is an alias for 'day', so it should be considered as such.
    if (units == 'date') :
        units = 'day'

    return this.startOf(units).add(**{('week' if  units == 'isoWeek' else units):1}).subtract(1, 'ms');
moment_.Moment.endOf=endOf

pandas

In [8]:
pd.options.display.max_rows = 999

# old groupbyDate 
pd.DataFrame.groupbyDate = (lambda self,
                                   freq,
                                   key="date",
                                  *args,
                                 **xargs: self.groupby(pd.Grouper(*args,
                                                                  key=key,
                                                                  req=freq,
                                                                  **xargs)))
# pandas groupByDate 
# groupByDate2( DataFrame, String, Int, String, String)
# dateCol = Column_Where_The_Date_is
# nbJ = Nombre_de_Jours
# closed = Début des groupes à droite ou à gauche ("right, "left")
# label = Label des groupes avec les dates de gauche ("left") ou les dates de la "droite"
def groupByDate2(df,
                 dateCol,
                 nbJ=7,
                 closed="right",
                 label="left",
                 *args,
                 **xargs):

    dfClosed=df[dateCol][::-1] if closed=="right" else df[dateCol] #on part du prinpie que c triée par date croissance, si right-> on trié par date décroissante
    dateActuelle= dfClosed.iloc[0] #premiere date, soit la plus basse (closed=left), soit la plus grande (closed=right)
    dansLeGroupe=True #indique quand on doit ouvrir/fermer un group (le groupe courant)
    groups={} # dico indiquant pour chaque index du dataframe, son groupe
    indiceDatesGroups=0 # indice qui s'incremente à chaque nouveau groupe créé
    datesGroups={} # dico contenant pour chaque groupe la date a affiché (en fonction de closed et label)
    dateDebutFinGroup=dateActuelle # date a l'ouverture du groupe
    dateFinDebutGroup=dateActuelle # date a la fermeture du groupe
    for indexCurr,dateCurr in dfClosed.items():
        dateDiff=((dateCurr - dateDebutFinGroup).days)*(-1 if closed=="right" else 1) # difference entre la date courante et la date du début de groupe (si closed "left" c'est positif sinon c'est négatif d'ou la multiplication par -1)
        if dateDiff >= nbJ: # si le nb de jours est dépassé le groupe prescendant est plein et on créé un autre groupe
            dansLeGroupe=False 
        if not dansLeGroupe: # si le groupe est plein
            datesGroups[indiceDatesGroups]=(dateFinDebutGroup if label=="left" else dateDebutFinGroup) if closed=="right" else (dateDebutFinGroup if label=="left" else dateFinDebutGroup) # on trouve la date a afficher en fonctionde closed et label
            indiceDatesGroups+=1 # on incremente l'indice de groupe
            dateDebutFinGroup=dateCurr # on change la date de debut du groupe
            dansLeGroupe=True
        if dansLeGroupe: # si le groupe n'est pas plein on rajoute l'element courant a ce groupe
            dateFinDebutGroup=dateCurr # on change la date de fin de groupe avec celle actuelle
            groups[indexCurr]=indiceDatesGroups
    datesGroups[indiceDatesGroups]=(dateFinDebutGroup if label=="left" else dateDebutFinGroup) if closed=="right" else (dateDebutFinGroup if label=="left" else dateFinDebutGroup)
    
    datesGrouped={ i:datesGroups[j] for i,j in groups.items()} # pour chaque groupe on lui affili sa date
    return df.groupby(pd.Series(datesGrouped,name=dateCol)) # on crée le groupby a partir des groupes créés


pd.DataFrame.groupByDate=groupByDate2
# agg method qui accepte les parametres avec clé valeur
pd.core.groupby.generic.DataFrameGroupBy.aggKV=lambda self,**args: self.agg(args)

#selectionne pour chaque valeur de la serie le maximum entre nb et cette valeur (par ex: pas de valeur < 0 qd nb=0) 
pd.Series.mini=lambda self,nb=0:self.apply(lambda g:np.max([g,nb]))

# add method mutate from dfply to pandas dataframe
pd.DataFrame.mutate=lambda self, **xargs : self >> df.mutate(**xargs)

studyPipe

In [9]:
# permet d'utiliser une fonction directement dans le pipe
# addToPipe(lambda a:a**2)
# addToPipe(np.max)
def addToPipe(a, convert=False):
    pipedFn=Pipe(lambda x: a,special=True) if not convert else convert_pipe(_c.curry(a))
    pipedFn.__doc__=a.__doc__
    return pipedFn

# forEach method comme en js, pour appliqué a chaque valeur d'une list un traitement
def forEach(a,b):
    list(map(a,b))
_ftools_.__class__.forEach=addToPipe(forEach,convert=T)

plotly

In [10]:
# permet d'utiliser l'operateur + entre deux Figure plotly et plotly_study
go.Figure.__add__ = lambda self,other: self.add_trace(other.data[0]) if other.__class__ is go.Figure else self
go2.Figure.__add__ = lambda self,other: self.add_trace(other.data[0]) if other.__class__ is go2.Figure else self

# ajoute un second axe à une figure existante, lié à yaxis2
def addSecondAxis(plotyFig):
    yaxis_layout_plotlyFig=plotyFig.layout["yaxis"].to_plotly_json().copy()
    yaxis_layout_plotlyFig.update(dict(anchor="x",
                                       overlaying="y",
                                       side="right",
                                       gridcolor= '#E1E5ED',
                                       showgrid= True,
                                       tickfont= {'color': '#4D5663'},
                                       title= {'font': {'color': '#4D5663'}, 'text': ''},
                                       zerolinecolor= '#E1E5ED'
                            ))
    plotyFig.layout["yaxis2"]= yaxis_layout_plotlyFig
    plotyFig.data[0].yaxis="y2"
    return plotyFig
addSecondAxis_ = addToPipe(addSecondAxis)

# ajoute un rangeSlider à une figure plotly
def addSlider(plotyFig):
    return plotyFig.update_layout(xaxis_rangeslider_visible=True)
addSlider_ = addToPipe(addSlider)

# fonction pour utiliser les methods de plotly express directement dans le pipe | 
pex.line_= addToPipe(pex.line)
px.line_= addToPipe(px.line)
pex.bar_= addToPipe(pex.bar)
px.bar_=addToPipe(px.bar)
pex.scatter_=addToPipe(pex.scatter)
px.scatter_=addToPipe(px.scatter)
pex.choropleth_=addToPipe(pex.choropleth)
px.choropleth_=addToPipe(px.choropleth)
showLegend=lambda a:a.update_traces(showlegend=True)
showLegend_=addToPipe(showLegend)

update_layout_=addToPipe(lambda a,*args,**xargs:a.update_layout(*args,**xargs))

# fonction pour ajouter facilement un hoverTemplate
# args= list de variable à ajouter au template
# dico= dico de clé valeur, qui represente  une valeur et son label a afficher
def hoverTemplate(*args,dicoFirst=False,**dico):
    keysDicoValues=list(dico.keys())
    values=range(len(args)) | _ftools_.mapl("customdata[{}]")
    if dicoFirst:
        keysDicoValues.extend(values)
        values=keysDicoValues
    else:
        values.extend(keysDicoValues)
    dicoLabels=list(dico.values())
    labels=list(args)
    if dicoFirst:
        dicoLabels.extend(labels)
        labels=dicoLabels
    else:
        labels.extend(dicoLabels)
    hovertemplate=[]
    for indice in range(len(values)):
        hovertemplate.append(f"<i>{labels[indice]}</i> : %{{{values[indice]}}}")
    return "<br>".join(hovertemplate)
    
hoverTemplate_ = addToPipe(hoverTemplate)

# convert mpl to plotly
def mpl_to_plotly2(fig=None):
    from plotly.tools import mpl_to_plotly as mpl_to_plotly_
    fig= plt.gcf() if fig is None else fig
    return mpl_to_plotly_(fig)
In [11]:
# fonction pour créer deux onglets html depuis deux figure
def tabs(fig1,fig2, fig1Name="Absolue", fig2Name="Log"):
    randomNumber=randomString()
    display_html("""
    <button id="tab1{random}" class="active-me{random}" onclick="selectTab{random}(1,this);">{fig1Name}</button>
    <button id="tab2{random}" onclick="selectTab{random}(2,this);">{fig2Name}</button>

    <br/>
     <div id="kk{random}">
    <div id="tab1Content{random}">
    {tab1}
    </div>
    <div id="tab2Content{random}">
      {tab2}
    </div>

    </div>
    <style>
    #tab1Content{random} {
    position: absolutes;
     visibility: visible; 
    }

    #tab2Content{random} {
    top:50px;
    width:90%;
    position: absolute;
     visibility: hidden; 
    }
    #kk{random} {
    width:100%;
    max-height:500px;
    }
    .active-me{random} {
    color: white;
    background-color:gray;
    }
    </style>
    <script>
    function selectTab{random}(tabIndex,th) {
      //Hide All Tabs
      document.getElementById('tab1Content{random}').style.visibility="hidden";
      document.getElementById('tab2Content{random}').style.visibility="hidden";

      document.getElementById('tab1{random}').classList.remove("active-me{random}")
      document.getElementById('tab2{random}').classList.remove("active-me{random}")
      th.classList.add("active-me{random}")



      //Show the Selected Tab
      document.getElementById('tab' + tabIndex + 'Content{random}').style.visibility="visible";  
    }
    </script>
    """.replace("{tab1}",fig1.to_html(include_plotlyjs="require",auto_play=False))
       .replace("{tab2}",fig2.to_html(include_plotlyjs="require",auto_play=False))
       .replace("{random}",randomNumber)
       .replace("{fig2Name}",fig2Name)
       .replace("{fig1Name}",fig1Name)
                )

dash

In [12]:
# afficher un dashboard dash dans un notebook
def show_app(app,  # type: dash.Dash
             port=10000,
             width=700,
             height=350,
             offline=True,
             style=True,
             **dash_flask_kwargs):
    """
    Run the application inside a Jupyter notebook and show an iframe with it
    :param app:
    :param port:
    :param width:
    :param height:
    :param offline:
    :return:
    """
    url = 'http://0.0.0.0:%d' % port
    iframe = '<iframe src="{url}" width={width} height={height}></iframe>'.format(url=url,
                                                                                  width=width,
                                                                                  height=height)
    display.display_html(iframe, raw=True)
    if offline:
        app.css.config.serve_locally = True
        app.scripts.config.serve_locally = True
    if style:
        external_css = ["https://fonts.googleapis.com/css?family=Raleway:400,300,600",
                        "https://maxcdn.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css",
                        "http://getbootstrap.com/dist/css/bootstrap.min.css", ]

        for css in external_css:
            app.css.append_css({"external_url": css})

        external_js = ["https://code.jquery.com/jquery-3.2.1.min.js",
                       "https://cdn.rawgit.com/plotly/dash-app-stylesheets/a3401de132a6d0b652ba11548736b1d1e80aa10d/dash-goldman-sachs-report-js.js",
                       "http://getbootstrap.com/dist/js/bootstrap.min.js"]

        for js in external_js:
            app.scripts.append_script({"external_url": js})

    return app.run_server(debug=False,  # needs to be false in Jupyter
                          port=port,
                          host="0.0.0.0",
                          **dash_flask_kwargs)

dfply

In [13]:
# fonction pour utiliser ses fonctions directement dans dfply
#log fonction
@make_symbolic
def log_(series):
    return np.log(series)

#si 0 -> nan
@make_symbolic
def zeroNan(a):
    return a.apply(lambda d: np.nan if d==0 else d)

#rien -> return seulement le param envoyé
@make_symbolic
def rien(s):
    return s

rpy

In [14]:
# check if the package "pkg" exist in R
def rPackageExist(pkg):
    try:
        importr(pkg)
    except:
        return False
    return True

# get the package "pkg" if exist if not install it in R
def rInstallIfNotExistPackage(pkg):
    utils = importr('utils')
    if not rPackageExist(pkg):
        print(f"install R package {pkg}...")
        utils.install_packages(pkg)
    return importr(pkg)

#factoMineR=rInstallIfNotExistPackage("FactoMineR")
#factoextra=rInstallIfNotExistPackage("factoextra")

eda

In [21]:
def getCountryFromData(country):
    global covidEdaTrainX
    return (covidEdaTrainX  >> 
            df.filter_by(X.Country_Region == country) |__
            .groupby(["Country_Region","Date"]).agg(dict(Deaths=sum,Confirmed=sum)) |__
            [slice(country, country)] |__
            .reset_index() |__
            .drop(["Country_Region"],axis=1))
def getCountryAndDtFromData(country):
    vv=getCountryFromData(country) 
    return vv >> df.mutate(d_Deaths_dt=np.gradient(vv.Deaths)) >> df.mutate(d_Deaths_dt=X.d_Deaths_dt.interpolate())
def getCountryAndDtsFromData(country):
    vv=getCountryFromData(country) 
    return vv >> df.mutate(d_Deaths_dt=np.gradient(vv.Deaths),
                           deces_jour=(X.Deaths - X.Deaths.shift())) >> df.mutate(d_Deaths_dt=X.d_Deaths_dt.interpolate().fillna(0),
                                                                                 deces_pct_change=(X.Deaths).pct_change().fillna(0),
                                                                                deces_pct_change_shift=(X.deces_jour).pct_change().fillna(0))
def graphDeathBy(pays, nbDays=1, log=False):
    nbI=nbDays
    le="d"
    title=pays
    argsO = {} if not log else dict(yaxis_type="log")
    if log:
        title+=" (log)"
    data1=(
        (getCountryAndDtsFromData(pays) >> df.mutate(nb=1)  |__
            .groupByDate("Date",nbDays, label='right', closed='right').agg({
                                           "Deaths":max,
                                           "nb":sum,
                                           "deces_jour":sum,
                                           "deces_pct_change":np.mean})).reset_index() >>
            df.mutate(Deaths_shift=(X.deces_jour*nbI/X.nb).replace({float("inf"):np.nan}).interpolate().fillna(0))>>
            df.mutate(deces_pct_change_shift2=X.Deaths_shift.pct_change().replace({float("inf"):np.nan}).interpolate().fillna(0),
                      Date_Deb=X.Date.apply(lambda b:moment(b.timestamp()).subtract(day=nbI).date.strftime("%b %d, %Y")) ) >>
            df.select("Date","Date_Deb",df.contains("Deaths"),df.contains("deces"),"nb") 
    
    ) 
    return (
        data1 |__fun__
        .listl( 
        px.line_(__,
                  x="Date",
                  y="deces_pct_change_shift2",
                  color_discrete_sequence=["red"]).update_traces(name=f"Variation du Deces/{nbI}j",mode="markers+lines"),
         px.scatter_(__,
                  x="Date",
                  y="Deaths",
                  color_discrete_sequence=["pink"]).update_traces(name=f"Décès Cumul"),
        px.bar_(__,
                 x="Date",
                 y="deces_jour",
                 text="deces_jour",
                 custom_data=["Date_Deb","Deaths","nb"]
                 ).update_traces(name=f"Deces/{nbI}j",
                                  offset=-nbI*24*60*60*1000,
                                  width=nbI*24*60*60*1000,
                                  hovertemplate=hoverTemplate("Date Début ",
                                                              "Décès Cumulés ",
                                                              "Nombre de jours ",
                                                              x="x [Date] ",
                                                              y=f"y [Décès/{nbI}j]",dicoFirst=True))
    ) |_ftools_
    .reduce(lambda a,b:a+b) |
    addSecondAxis_ |
    addSlider_ |
    showLegend_ |__.
    update_layout(title=title,
                  yaxis=dict(title=f"Nombre de décès/{nbI}j",
                            titlefont=dict(
                                            color="blue"
                                        ),
                                        tickfont=dict(
                                            color="blue"
                                        )),
                  yaxis2=dict(title=f"Variation du Nombre de décès/{nbI}j",
                             titlefont=dict(
                                            color="red"
                                        ),
                                        tickfont=dict(
                                            color="red"
                                        )),**argsO)
    )
graphDeathBy_=addToPipe(graphDeathBy)
In [16]:
def graphPopu(popuMondeTranches, log=False, both=False):
    title="Population par pays"
    if both:
        log=False
    fnLog=rien if not log else log_
    if log:
        title+=" (log)"
    figA=(
               (popuMondeTranches >> 
                    df.mutate( popu=fnLog( X.popu*1000 ) )) | 
                px.choropleth_(__,
                               locations="pays",
                               locationmode="country names",
                               color="popu",
                               title=title,
                               color_continuous_scale=px.colors.sequential.Bluered)
           )
    if both:
        fnLog=log_
        title+=" (log)"
        fig2=(
               (popuMondeTranches >> 
                    df.mutate( popu=fnLog( X.popu*1000 ) )) | 
                px.choropleth_(__,
                               locations="pays",
                               locationmode="country names",
                               color="popu",
                               title=title,
                               color_continuous_scale=px.colors.sequential.Bluered)
           )
        figA=tabs(figA,fig2)
    return figA

graphPopu_=addToPipe(graphPopu)

def graphPopuTranchesAge(popu,byPopu=False,**args):
    pop=popu >>  df.spread("tranches_age","value") >> df.mutate(popu=X.popu*1000) 
    title="Population dans le Monde "
    if byPopu:
        pop=pop >> df.group_by("pays") >> df.mutate(**{i:X[i]/X.popu*100 for i in ["A","B","C","D","E"]})
        title+=" (par rapport à leur popu %)"
    fig= ( pop| _fun_.
     listl(
         
        px.choropleth_(__,locations="pays",locationmode="country names",color="A",color_continuous_scale=px.colors.sequential.Bluered),
        px.choropleth_(__,locations="pays",locationmode="country names",color="B",color_continuous_scale=px.colors.sequential.Bluered),
        px.choropleth_(__,locations="pays",locationmode="country names",color="C",color_continuous_scale=px.colors.sequential.Bluered),
        px.choropleth_(__,locations="pays",locationmode="country names",color="D",color_continuous_scale=px.colors.sequential.Bluered),
        px.choropleth_(__,locations="pays",locationmode="country names",color="E",color_continuous_scale=px.colors.sequential.Bluered))| _ftools_
          .reduce(lambda a,b:a+b).update_traces(visible=False))
    _=fig.data[0].update(visible=True)
    return fig.update_layout(
        title=title+" : Moins de 15 ans",
        updatemenus=[
            dict(
                active=0,
                buttons=list([
                    dict(label="Moins de 15 ans",
                         method="update",
                         args=[{"visible": [True, False, False, False, False]},
                               {"title": title+" : Moins de 15 ans"}]),
                    dict(label="15-44",
                         method="update",
                         args=[{"visible": [False, True, False, False, False]},
                               {"title": title+" : 15-44"}]),
                    dict(label="45-64",
                         method="update",
                         args=[{"visible": [False, False, True, False, False]},
                               {"title": title+" : 45-64"}]),
                    dict(label="65-74",
                         method="update",
                         args=[{"visible": [False, False, False, True, False]},
                               {"title": title+" : 65-74"}]),
                    dict(label="Plus de 75 ans",
                         method="update",
                         args=[{"visible": [False, False, False, False, True]},
                               {"title": title+" : Plus de 75 ans"}])
                ]),
            )
    ])
In [17]:
def searchPays( pays,ddz):
    return ( ddz | _ftools_
                    .mapl(lambda a:pays in a) |_fun_
                    .np.argwhere(__) | _ftools_
                    .mapl(lambda a: a[0] if len(a)>0 else []) | _ftools_
                    .mapl(lambda a:[a,ddz[a]])) | addToPipe(lambda a:None if len(a)==0 else a[0])
def searchPaysNotJoined(feg, ddz):
    
    return ( np.argwhere(
        feg
            .map(lambda a: np.where(ddz==a.lower())[0].shape[0]>0 ).values == False
    ).reshape(-1) |_ftools_
        .mapl(lambda a:feg[a])
    ) | _ftools_.mapl(lambda a:[a,searchPays(a.lower(),ddz)])

def joinCovidDeathsAndPopu(covidEdaTrainX, popuMondeTranches):
    fzf=(
        covidEdaTrainX.groupby(["Country_Region","Date"]).sum().reset_index("Date")
    ).join(popuMondeTranches.set_index("pays"))
    ddz=popuMondeTranches.pays.str.lower().values
    feg=covidEdaTrainX.Country_Region.value_counts().index
    dg=searchPaysNotJoined(feg,ddz)
    #print(dg)
    vr=popuMondeTranches.set_index("pays")
    #return fzf,dg
    for i,j in dg:
         if j is not None:
            #print(j[0])
            fzf.loc[i,"popu"]=popuMondeTranches.iloc[j[0],:].loc["popu"]
    fzf.loc["US","popu"]=popuMondeTranches.set_index("pays").loc["United States of America","popu"].iloc[0]
    return fzf.reset_index().rename(columns={"index":"Country_Region"})
In [18]:
def graphDeaths(covidEdaTrainX,groupByDate=None,debut=moment(2010,2,25).date,log=False,both=False,noNan=False,
               cummulative=False):
    XXF=covidEdaTrainX.groupby(["Country_Region","Date"]).aggKV(Deaths=sum).reset_index()
    if both:
        log=False
    fnLog=rien if not log else log_
    fnNan=rien if noNan else zeroNan
    title="Nombre de décès par pays"
    if log:
        title+=' (log)'
    if groupByDate is not None:
        XXF=(
            ((covidEdaTrainX | __
                .groupby(["Country_Region","Date"]).aggKV(Deaths=sum).reset_index("Date")) >> 
             df.group_by("Country_Region") >> df.mutate(Deaths=(X.Deaths - X.Deaths.shift()).fillna(0).mini(0))) | addToPipe(
                    lambda a: a.groupby('Country_Region').groups.items() % _ftools_
                                                                         .mapl(lambda i: a.loc[i[0]].reset_index().groupByDate("Date",label="right",nbI=groupByDate).aggKV(Deaths=sum).reset_index() | __
                                                                             .set_axis( [i[0]]*__.shape[0],inplace=F) )) |_fun_.
            pd.concat
        )
        XXF=XXF.reset_index().rename(columns={"index":"Country_Region"})
        if cummulative:
            XXF=XXF >>df.group_by(X.Country_Region) >> df.mutate(Deaths=df.cumsum(X.Deaths))
            title+= " (cummul)"
        title=title+f" (par {groupByDate} jours)"
    
    figA=((XXF  >>
     df.mutate(Date_D=X.Date.dt.strftime("%d-%m-%y"),
              Deaths=fnNan(X.Deaths)) >> 
    df.mutate(Deaths=fnLog(X.Deaths))>>
     df.filter_by( X.Date > debut ) 
    )|_fun_.
    px.choropleth(__,
                   animation_frame="Date_D",
                   locations="Country_Region",
                  color_continuous_scale=px.colors.sequential.Bluered,
                   locationmode="country names",
                   color="Deaths") |__
    .update_layout(title=title))

    if both:
        fnLog=log_
        title+=" (log)"
        fig2=((XXF  >>
     df.mutate(Date_D=X.Date.dt.strftime("%d-%m-%y"),
              Deaths=fnNan(X.Deaths)) >> 
    df.mutate(Deaths=fnLog(X.Deaths))>>
     df.filter_by( X.Date > debut ) 
    )|_fun_.
    px.choropleth(__,
                   animation_frame="Date_D",
                   locations="Country_Region",
                  color_continuous_scale=px.colors.sequential.Bluered,
                   locationmode="country names",
                   color="Deaths") |__
    .update_layout(title=title))
        figA=tabs(figA,fig2)
    return figA

def graphDeathsByPopu(covidEdaTrainX, popuMondeTranches,groupByDate=None, log=False, both=False, animation=False, date="last",
                     debut=moment(2010,2,25).date,cummulative=False,**args):
    gj=joinCovidDeathsAndPopu(covidEdaTrainX, popuMondeTranches)
    title="Nombre de décès par pays par rapport à leurs populations"
    opts={}
    fnDateD= lambda X:X.dt.strftime("%d-%m-%y")
    if groupByDate:
        animation=True
    if not animation:
        if date=="last":
            gj=gj.groupby(["Country_Region","tranches_age"]).last().reset_index()
            title+=" (lastDay)"
        else:
            gj = (gj  >> df.filter_by(X.Date >= date)) | __.groupby(["Country_Region","tranches_age"]).first().reset_index()
            title+=f" (~{date.strftime('%d-%m-%y')})"
    else:
        opts["animation_frame"]="Date_D"
        title+=" (byDate)"
        #fnDateD= lambda X:X.dt.strftime("%d-%m-%y")
    if both:
        log=False
    fnLog=log_ if log else rien
    if log:
        title+=" (log)"
    if groupByDate is not None:
        #return gj
        gj=(
            ((gj | __
                .groupby(["Country_Region","Date"]).aggKV(Deaths=sum,popu=np.max).reset_index("Date")) >> 
             df.group_by("Country_Region") >> df.mutate(Deaths=(X.Deaths - X.Deaths.shift()).fillna(0).mini(0))) | addToPipe(
                    lambda a: a.groupby('Country_Region').groups.items() % _ftools_
                                                                         .mapl(lambda i: a.loc[i[0]].reset_index().groupByDate("Date",label="right",nbI=groupByDate).aggKV(Deaths=sum,popu=np.max).reset_index() | __
                                                                             .set_axis( [i[0]]*__.shape[0],inplace=F) )) |_fun_.
            pd.concat
        )
        gj=gj.reset_index().rename(columns={"index":"Country_Region"})
        if cummulative:
            gj=gj >> df.group_by(X.Country_Region) >> df.mutate(Deaths=df.cumsum(X.Deaths))
            title+= " (cummul)"
        title=title+f" (par {groupByDate} jours)"
    
    gj=gj>>df.mutate(Deaths=make_symbolic(lambda a:a.transform(lambda b:np.max([b,0])))(X.Deaths))
    #return gj
    figA= ((
        gj.reset_index() >> 
     df.filter_by( X.Date > debut ) >>
        df.mutate(Deaths_by_popu=X.Deaths/(X.popu*1000)*100.0,Date_D=fnDateD(X.Date)) >> 
        df.mutate(Deaths_by_popu=fnLog(X.Deaths_by_popu)) >> 
        df.mutate(**{"Deaths_by_popu (%)":make_symbolic(lambda a:np.round(a,4))(X.Deaths_by_popu)})) | 
         px.choropleth_(__,
                       locations="Country_Region",
                        hover_data=["Date_D","Deaths","popu","Deaths_by_popu (%)"],
                       locationmode="country names",
                         color_continuous_scale=px.colors.sequential.Bluered,
                       color="Deaths_by_popu",**opts) |__
        .update_layout(title=title))
    
    if both:
        fnLog=log_
        title+=" (log)"
        fig2= ((
        gj.reset_index() >> 
     df.filter_by( X.Date > debut ) >>
        df.mutate(Deaths_by_popu=X.Deaths/(X.popu*1000)*100.0,Date_D=fnDateD(X.Date)) >> 
        df.mutate(Deaths_by_popu=fnLog(X.Deaths_by_popu))) | 
         px.choropleth_(__,
                       locations="Country_Region",
                        hover_data=["Date_D","Deaths","popu"],
                         **opts,
                       locationmode="country names",
                         color_continuous_scale=px.colors.sequential.Bluered,
                       color="Deaths_by_popu") |__
        .update_layout(title=title))
        figA=tabs(figA,fig2)
    return figA
prep
In [19]:
# prep custom function
def as_int2(self,li):
    li = li if isinstance(li,collections.abc.Iterable) and not isinstance(li,str) else [li]
    self._data[li]=self._data[li].apply(lambda a:unNamesEscape(a.values),axis=0)
    self._data[li]=self._data[li].astype("int")
    return self

Le Projet

Regroupe les données pour un projet

In [22]:
Covidproj = StudyProject.getOrCreate("covid")

Les Données

on liste les données disponible dans le projet

In [23]:
list(Covidproj.data.keys())
Out[23]:
['covidTemporalAllCountry',
 'popuMondeTranches',
 'lifeExpectancy',
 'beds',
 'doctors']

on check pour voir s'il y a des maj de données nécessaires

In [27]:
okData=getData(silent=True)
okDataPopu=T#getDataPopu(silent=True)
okDataLife=T#getDataLife(silent=True)
okDataBeds=T
okDataDoctors=T

Si déjà exporté

In [28]:
if "covidTemporalAllCountry" in Covidproj.data and okData: 
    print("covidTemporalAllCountry déjà dans le projet")
else:
    print("/!\ covidTemporalAllCountry pas exporté")
    
# if "covidDataFr" in Covidproj.data and okDataFr:
#     print("covidDataFr déjà dans le projet")
# else:
#     print("/!\ covidDataFr pas exporté")

if "popuMondeTranches" in Covidproj.data and okDataPopu:
    print("popuMondeTranches déjà dans le projet")
    popuMondeTranches=Covidproj.data["popuMondeTranches"].dataTrain.X
else:
    print("/!\ popuMondeTranches pas exporté")

if "lifeExpectancy" in Covidproj.data and okDataLife:
    print("lifeExpectancy déja dans le projet")
    lifeExp=Covidproj.data["lifeExpectancy"].dataTrain.X
else:
    print("/!\ lifeExpectancy pas exporté")
    
if "beds" in Covidproj.data and okDataBeds:
    print("beds déja dans le projet")
    beds=Covidproj.data["beds"].dataTrain.X
else:
    print("/!\ beds pas exporté")
    
if "doctors" in Covidproj.data and okDataDoctors:
    print("doctors déja dans le projet")
    doctors=Covidproj.data["doctors"].dataTrain.X
else:
    print("/!\ doctors pas exporté")
covidTemporalAllCountry déjà dans le projet
popuMondeTranches déjà dans le projet
lifeExpectancy déja dans le projet
beds déja dans le projet
doctors déja dans le projet

Si pas exporté

In [29]:
if "covidTemporalAllCountry" not in Covidproj.data or not okData:
    print("covidTemporalAllCountry not in project")
    covidData = getData(T) # on récupere les données
    covidData.Date = pd.to_datetime(covidData.Date)
    covidData["Country_Region"]=covidData["Country_Region"].astype("category")
    covidData["Province_State"]=covidData["Province_State"].astype("category")
    Covidproj.saveDatasWithId("covidTemporalAllCountry",covidData,pd.Series(name="__fake__"),
                                                     pd.DataFrame(),pd.Series(name="__fake2__")) # on ajoute les données dans le projet
    Covidproj.export()
    print("ok")
    
# if "covidDataFr" not in Covidproj.data or not okDataFr:
#     print("covidDataFr not in project")
#     covidData = getDataFr()
#     covidData.date = pd.to_datetime(covidData.date)
#     Covidproj.saveDatasWithId("covidDataFr",covidData,pd.Series(name="__fake__"),
#                                             pd.DataFrame(),pd.Series(name="__fake2__"))
#     Covidproj.export()
#     print("ok")
    
if "popuMondeTranches" not in Covidproj.data or not okDataPopu:
    print("popuMondeTranches not in project")
    popuMondeTranches=getDataPopu()
    Covidproj.saveDatasWithId("popuMondeTranches",popuMondeTranches,pd.Series(name="__fake__"),
                                                  pd.DataFrame(),pd.Series(name="__fake2__"))
    Covidproj.export()
    print("ok")
    
if "lifeExpectancy" not in Covidproj.data or not okDataLife:
    print("lifeExpectancy not in project")
    lifeExp = getDataLife()
    Covidproj.saveDatasWithId("lifeExpectancy",lifeExp,pd.Series(name="__fake__"),
                                                  pd.DataFrame(),pd.Series(name="__fake2__"))
    Covidproj.export()
    print("ok")

if "beds" not in Covidproj.data or not okDataBeds:
    print("beds not in project")
    beds = getDataBeds()
    Covidproj.saveDatasWithId("beds",beds,pd.Series(name="__fake__"),
                                                  pd.DataFrame(),pd.Series(name="__fake2__"))
    Covidproj.export()
    print("ok")
    
if "doctors" not in Covidproj.data or not okDataDoctors:
    print("doctors not in project")
    doctors = getDataDoctors()
    Covidproj.saveDatasWithId("doctors",doctors,pd.Series(name="__fake__"),
                                                  pd.DataFrame(),pd.Series(name="__fake2__"))
    Covidproj.export()
    print("ok")

(OMIT) EDA

In [19]:
covidEda.datas
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-19-4db1fd671149> in <module>
----> 1 covidEda.datas

NameError: name 'covidEda' is not defined
In [176]:
covidEda.train_datas._edaOpts=dict(progress_bar=False,
                                  html={'style':{'full_width':True}})
In [177]:
covidEda.train_datas.eda
                        creating EDA ProfileReport... (think to export the study(Project) !!)

Out[177]:
eda, attribute available : overview, variables, interactions, correlations, missing, sample
In [170]:
covidEda.train_datas.eda.overview
Out[170]:

In [105]:
covidEda.train_datas.eda.variables
Out[105]:

In [106]:
covidEda.train_datas.eda.correlations
Out[106]:

In [109]:
covidEda.train_datas.eda.missing
Out[109]:

In [110]:
covidEda.train_datas.eda.sample
Out[110]:

In [113]:
covidEda.datas.prep.addCustomFunction(as_int2)
In [117]:
covidEda.datas.eda.hints
Out[117]:
Results Observations
Shape train (7926, 9) | test (0, 1)
Nulls NaN Use prep.impute.
Outliers Upper [Confirmed, Deaths, Recovered] Positive skew (> 3). Use prep.outliers(upper).
Numerical Ratio 44% Aim for 100% numerical.
Numerical High-cardinality [Confirmed, Deaths, Recovered] (>10) categories. Use prep.density
Numerical Continuous [SNo] ~80% unique. Use viz.continuous.
Text High-cardinality [Province/State, Country/Region, Last Update, ... (>10) categories. Use prep.labels.
Target Analysis (FAKE) Nothing Nothing
Speedml Release v0.9.3 Visit https://speedml.com for release notes.
In [119]:
(covidEda.train_datas.viz.plot("Confirmed") 
    | __.update_layout(xaxis=dict(range=[0,1*1000])))
In [182]:
with covidEda.datas.getTmp() as datas_:
    datas_.dataTrain.prep.data["ObservationDate2"]=datas_.dataTrain.ObservationDate.dt.strftime("%d %B %Y")
    pex.line(datas_.dataTrain >> df.arrange(df.desc(X["Deaths"])) >> df.row_slice(rangel(100)), hover_data=["ObservationDate2"],
                x="ObservationDate",
                y="Deaths",
                color="Country/Region",
                 log_y=True
                )
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-182-9f58a7f76951> in <module>
      1 with covidEda.datas.getTmp() as datas_:
----> 2     datas_.dataTrain.prep.data["ObservationDate2"]=datas_.dataTrain.ObservationDate.dt.strftime("%d %B %Y")
      3     pex.line(datas_.dataTrain >> df.arrange(df.desc(X["Deaths"])) >> df.row_slice(rangel(100)), hover_data=["ObservationDate2"],
      4                 x="ObservationDate",
      5                 y="Deaths",

/opt/conda/lib/python3.6/site-packages/pandas/core/generic.py in __getattr__(self, name)
   5173             or name in self._accessors
   5174         ):
-> 5175             return object.__getattribute__(self, name)
   5176         else:
   5177             if self._info_axis._can_hold_identifiers_and_holds_name(name):

/opt/conda/lib/python3.6/site-packages/pandas/core/accessor.py in __get__(self, obj, cls)
    173             # we're accessing the attribute of the class, i.e., Dataset.geo
    174             return self._accessor
--> 175         accessor_obj = self._accessor(obj)
    176         # Replace the property with the accessor object. Inspired by:
    177         # http://www.pydanny.com/cached-property.html

/opt/conda/lib/python3.6/site-packages/pandas/core/indexes/accessors.py in __new__(cls, data)
    341             pass  # we raise an attribute error anyway
    342 
--> 343         raise AttributeError("Can only use .dt accessor with datetimelike " "values")

AttributeError: Can only use .dt accessor with datetimelike values
In [183]:
covidEda.train_datas.prep.data.ObservationDate
Out[183]:
0       22 January 2020
1       22 January 2020
2       22 January 2020
3       22 January 2020
4       22 January 2020
             ...       
7921      22 March 2020
7922      22 March 2020
7923      22 March 2020
7924      22 March 2020
7925      22 March 2020
Name: ObservationDate, Length: 7926, dtype: object

La Study

On crée une study (étude) pour chaque jeu de données que l'on va utilisé (une étude -> un jeu de données)

In [30]:
covidEda=Covidproj.addOrGetStudy("covidEda")
if covidEda.datas is None or not okData:#or T:
    print("set covidTemporalAllCountry to Study")
    covidEda.setDataTrainTest(id_="covidTemporalAllCountry")
    Covidproj.export()
covidEda
Out[30]:
[[StudyClassifProject]
	ID : covidEda
	datas : [[DatasSuperviseClassif]
			ID : bzbbmywhtu
			dataTrain : [[DatasClassif]
					ID : fjswfykqwp
					X : (17920, 7),
					y : (0,)],
			dataTest : [[DatasClassif]
					ID : vwwovtfngo
					X : (0, 0),
					y : (0,)]],
	models : None,
	metric : [[Metric]
			ID : ymuwymwlhn],
	cv : Empty,
	nameCvCurr : None
	project : [[StudyProject]
			ID : covid],
	idDataProject : covidTemporalAllCountry,
	proprocessDataFromProjectFn : None,
	isProcessedDataFromProject : False]
In [255]:
# covidEdaFr=Covidproj.addOrGetStudy("covidEdaFr")
# if covidEdaFr.datas is None or not okDataFr:#or T:
#     print("set covidDataFr to Study")
#     covidEdaFr.setDataTrainTest(id_="covidDataFr")
#     Covidproj.export()
# covidEdaFr
set covidDataFr to Study
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-255-6441a4ec35be> in <module>
      2 if covidEdaFr.datas is None or not okDataFr:#or T:
      3     print("set covidDataFr to Study")
----> 4     covidEdaFr.setDataTrainTest(id_="covidDataFr")
      5     Covidproj.export()
      6 covidEdaFr

/opt/conda/lib/python3.7/site-packages/studyProject/project/project.py in setDataTrainTest(self, X_train, y_train, X_test, y_test, namesY, id_, force)
    516             raise KeyError("if id_ is specified, project must be set")
    517         if id_ is not None and id_ not in self.project.data:
--> 518             raise KeyError("id_ not in global")
    519         if id_ is not None:
    520             # y=self.project.data[id_]

KeyError: 'id_ not in global'
In [31]:
okData=getData(silent=True)
okDataFr=T

Alert Good Init

In [39]:
display_html("""
<script>
alert('Initialisation Effectuée')
</script>
""")
clear_output()

EDA (Tech)

on crée ses variables pour faciliter les choses

In [33]:
covidEdaTrain = covidEda.train_datas
covidEdaTrainX = covidEdaTrain.X
covidEdaData = covidEda.datas

Le Covid-19 à l'échelle mondiale

Introduction Démographique, et sociaux économiques

Démographie

On veut ici avoir un vue d'ensemble (mondiale) sur le Covid-19.
On va pour commencer étudier la démographie de chaque pays.

In [437]:
popuMondeTranches | graphPopu_(both=T)

On remarque que la chine et l'inde on le plus d'habitants.
Ensuite États Unis, Brésil, Nigéria ...

On va maintenant regarder les différences par classes d'âges

In [1109]:
graphPopuTranchesAge(popuMondeTranches, byPopu=F)

Globalement il y a en a le plus de chaque tranche en inde, chine, puis pakinstan, usa
-15 ans il y a aussi nigeria
+15 ans les usa aussi

In [1110]:
graphPopuTranchesAge(popuMondeTranches, byPopu=T)

Pour les moins de 15 ans:
                                             bcp: Il y a en a bcp en afrique en proportion (peut etre une explication par rapport au covid-19 en Afrique)                                              moyen: magreb, l'afrique du sud, argentine, mexique, inde, kazashstan
                                             faible: USa, canada, europe, australie, chine

Pour les 15-44 ans:
                                             bcp: Oman, United Arab Emirates
                                             moyen: Afrique, amérique latine, inde
                                             faible: USa, canada, europe, australie, chine

Pour les 45-64 ans:
                                             bcp: Europe, Chine, USA, australie
                                             moyen: amerique latine, inde
                                             faible: USa, canada, europe, australie, chine

taux urba

densiteHab

Politique

The scale goes from -10 (full autocracy) to 10 (full democracy).
Anocracies are those scoring between -5 and 5.

In [1128]:
politicalRegime=pd.read_csv("./data/political-regime.csv")
In [1165]:
(
    politicalRegime.groupby("Entity").last().reset_index() | 
    __.rename(columns=(__.columns[-1] |_fun_| listl,["Political Regime"]) |_funs_| zip |_fun_| dict ) |
    px.choropleth_(__,
                  locations="Entity",
                  locationmode="country names",
                  title="Regime Politique dans le monde",
                color_continuous_scale=px.colors.sequential.Bluered_r,
                  color=__.columns[-1])
)

les pays autocratique: Arabie Saudite, Chine, Kazakhstan, Iran, Syrie, Corée du Nord, Vietnam, Laos, Oman, Cuba
Les pays anocratiques fermé: qq pays d'afrique (magreb sauf tunisie), Thailand, Afganistan
Les pays anocratiques ouverts: qq pays d'afrique, tunisie,Venezuela, Russie, Yemen
les pays democratiques: europe, qq pays d'afrique (Ghana, Kenya, Zambie, Afrique du sud ), Amerique, inde, Australie, Japon, Corée du sud, indonesie, malaisie

Indicateurs Santé

In [984]:
(lifeExp | 
    px.choropleth_(__,
                   locations="Country",
                   locationmode="country names",
                   color=__.columns[3],
                   color_continuous_scale=px.colors.sequential.Bluered,
                   title="Espérance de Vie en Bonne santé") |__
    .update_layout(annotations=[
        dict(
            showarrow=False,
            text="Nombre moyen d'années qu'une personne peut espérer vivre en 'pleine santé'</br></br>en tenant compte des années vécues en moins de pleine santé en raison d'une maladie et / ou d'une blessure.",
            xanchor='right',
            align="left",
            x=1.1,
            yanchor='top',
            y=-0.1
        )])
)

Europe, Amerique, chine, japon, australie -> Elévé
Afrique (sauf magreb), Afganistan -> moyen bas

J'ai le nombre de mort par ans -> par mois
A mettre en oposition avec le nb de mort du coronavirus

In [204]:
deathRates=pd.read_csv("data/DeathsRateWorld.csv")
In [361]:
(
    deathRates |
    px.choropleth_(__,
                  locations="Country",
                  locationmode="country names",
                   title="Taux de décès pour 100000 personnes dans le monde",
                  color=__.columns[-1],
                  color_continuous_scale=px.colors.sequential.Bluered)
)
In [1166]:
(
    doctors.rename(columns=dict(MedicalDoctorsPer100000="Docteurs / 100,000.0"))|
    px.choropleth_(__,
                   locations="Country",
                   locationmode="country names",
                   title="Docteurs pour 100,000 personnes dans le monde",
                   color=__.columns[2],
                   color_continuous_scale=px.colors.sequential.Bluered)
)

Bcp: Cuba, Uruguay, Greece, portugal, géorgie, belarus Moyen: Australie, Argentine, Russie, FR, Espagne, Italie, allemagne, suede, finland moyen -bas: pologne, UK, USA, Canada,Mexique, Bresil, Saudi, Mongolie, Kzakhtan, japan bas: afrique, inde, chine, iran, irak, turquie, afganistan

In [1167]:
hospitals=beds.loc[:,["Country",beds.columns[2]]]
In [1171]:
(
    hospitals 
        .rename(columns=dict(HospitalBedsPer100000="Hospital Beds / 100000"))
                |
    px.choropleth_(__,
                  locationmode="country names",
                  locations="Country",
                   title="Nombre de Lits D'Hôpitaux pour 100000 personnes dans le monde",
                  color_continuous_scale=px.colors.sequential.Bluered,
                  color=__.columns[-1])
)

On remarque le japon, les corées, la rusie, belarusie, allemagne, Ukraine Haut
On remarque Fr, argentine, Bulgarie,Pologne, moyen
On remarque afrique, asie (chine, inde,australie), Amerique assez bas

acute_beds
Les lits de soins curatifs (soins actifs|soins aigus) dans les hôpitaux (HP.1) sont des lits d'hôpitaux disponibles pour les soins curatifs

In [352]:
hospitalsAcute=beds.loc[:,["Country",beds.columns[3]]]
In [353]:
(
    hospitalsAcute | 
    px.choropleth_(__,
                  locationmode="country names",
                  locations="Country",
                title="Nombre de lits de sois curatifs pour 100000 personnes dans le monde",
                  color_continuous_scale=px.colors.sequential.Bluered,
                  color=hospitalsAcute.columns[-1])
)

On remarque allemagne, bulgarie, autriche, japon, corée du sud +
On rmrq inde, iran, UK, Usa -

In [355]:
hospitalsICU=beds.loc[:,["Country",beds.columns[4]]]
In [356]:
(
    hospitalsICU | 
    px.choropleth_(__,
                  locationmode="country names",
                  locations="Country",
                   title="Nombre de lits en soins intensifs pour 100000 personnes dans le monde",
                  color_continuous_scale=px.colors.sequential.Bluered,
                  color=hospitalsICU.columns[-1])
)

rmrq USA, kazakthan arabi saoudite, allemagne,roumanie, taiwan +
rmrq canada, fr, it, espagne, japon, corée du sud +/-
rmrq chine, inde, iran, -

Prop immunodeprimé ?

Alphabetisation ?

Les Cas Contaminés

Les cas contaminés annoncés par chaque pays, ne représente seulement que les cas testés.
Il y a bcp de cas asymptomatique donc pas testé.

In [91]:
tests=pd.read_csv("data/testsWorld.csv",usecols=range(2))
In [116]:
fig1=( 
    tests.mutate(testsPer100000=X.testsPer10000*10)
         .mutate(testsPer100000Log=log_(X.testsPer100000))|
    px.choropleth_(__,
                  locations="Country",
                  locationmode="country names",
                  title="Nombre de tests par pays pour 100 000 (log)",
                  color=__.columns[-1])
)
fig2=( 
    tests.mutate(testsPer100000=X.testsPer10000*10)|
    px.choropleth_(__,
                  locations="Country",
                  locationmode="country names",
                  title="Nombre de tests par pays pour 100 000",
                  color=__.columns[-1])
)
tabs(fig2,fig1)

Bcp de tests: Island, UAE norvege, canada, australie, Corée du sud
Peu de tests: FRance, Pologne, Iran,USA

fe

Comme en France ou en italie on ne tests que les cas sévères (dû à une incapacité pour l'instant de faire des tests généralisés), le pourcentage de cas positifs est élevé.
On voit qu'en Corée du Sud il y a donc moins de cas +, car des tests plus massifs, comme en allemagne.
On verra par la suite les stratégies possibles pour arrêter une épidemie.

In [364]:
(
    covidEdaTrainX.groupby(["Country_Region","Date"]).sum().groupby("Country_Region").last().reset_index() | 
    px.choropleth_(__,
                  locations="Country_Region",
                  locationmode="country names",
                   title="Nombre de cas Confirmé par pays",
                  color="Confirmed")
)

suite -> confirmed by popu, by log , temporel, groupbyDate

Les Décès

In [38]:
graphDeaths(covidEdaTrainX, both=True, groupByDate=7, cummulative=F)

In [41]:
graphDeaths(covidEdaTrainX, both=True, groupByDate=7, cummulative=T)

In [42]:
graphDeathsByPopu(covidEdaTrainX,popuMondeTranches,both=T,animation=T,groupByDate=7)

In [39]:
display_html("<style> div.output_scroll {height: 40em} </style>")
(
    covidEdaTrainX |__
        .groupby( "Country_Region" ).aggKV( Deaths=sum ) |__
        .sort_values( "Deaths", ascending=F ) |__
        .index[:20].tolist() |_ftools_
        .forEach( graphDeathBy_(__,7).show() )
)
In [40]:
figA=(
    covidEdaTrainX
        .groupby(["Country_Region","Date"]).sum()
        .reset_index()
        .groupby('Country_Region').last()
        .reset_index()
       | #.mutate(Deaths=log_(X.Deaths))|
    px.choropleth_(__,
                 locations="Country_Region",
                 locationmode="country names",
                   title="Mort Cummulés Par pays (Derniere Date)",
                   color_continuous_scale=px.colors.sequential.Bluered,
                 color="Deaths")
)
fig2=(
    covidEdaTrainX
        .groupby(["Country_Region","Date"]).sum()
        .reset_index()
        .groupby('Country_Region').last()
        .reset_index()
     .mutate(Deaths=log_(X.Deaths))|
    px.choropleth_(__,
                 locations="Country_Region",
                 locationmode="country names",
                   title="Mort Cummulés Par pays (Derniere Date) (log)",
                   color_continuous_scale=px.colors.sequential.Bluered,
                 color="Deaths")
)
tabs(figA,fig2)

On peux remarqué qu'il n'y a preque pas de mort en afrique et kazakstan, russie (pays autoritaire)

Les Rétablis

Le Covid-19 en Europe

Le Covid-19 en France (OLD) (A Modifier)

In [34]:
covidEdaFrTrain = covidEdaFr.train_datas
covidEdaFrTrainX = covidEdaFrTrain.X
covidEdaFrData = covidEdaFr.datas
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-34-3d2f36588fa1> in <module>
----> 1 covidEdaFrTrain = covidEdaFr.train_datas
      2 covidEdaFrTrainX = covidEdaFrTrain.X
      3 covidEdaFrData = covidEdaFr.datas

NameError: name 'covidEdaFr' is not defined
In [749]:
covidEdaFrTrainX >>= (df.mutate(d_deces_dt=np.gradient(covidEdaFrTrainX.deces),
                               deces_jour=(X.deces - X.deces.shift())) >> 
                      df.mutate(d_deces_dt=X.d_deces_dt.interpolate(),
                                deces_pct_change=(X.deces+1).pct_change().fillna(0),
                               deces_pct_change_shift=(X.deces_jour+1).pct_change().fillna(0)))
In [146]:
(
    (
       covidEdaFrTrainX |
         px.line_(__,
                   x="date",
                   y="deces_pct_change_shift",
                   color_discrete_sequence=["red"]).update_traces(name="Variation du nombre</br></br> de décès par jours")
    ) + (
         covidEdaFrTrainX |
         px.bar_(__,
                  x="date",
                  y="deces_jour",
                  text="deces_jour").update_traces(name="Décès par jours")
    ) |
    addSecondAxis_ |
    addSlider_ |
    showLegend_ |__.
    update_layout(
        title="France",
        legend=dict(valign="middle"),
        showlegend=True,
        xaxis=dict(
            range=["2020-03-08",moment("yesterday").endOf("day")],
            type="date")
    )
)
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-146-f48d8159aaf4> in <module>
     15     addSecondAxis_ |
     16     addSlider_ |
---> 17     showLegend_ |__.
     18     update_layout(
     19         title="France",

/opt/conda/lib/python3.7/site-packages/studyPipe/studyPipe.py in ror_callable(self, other)
    288 
    289 def ror_callable(self, other):
--> 290     ret = _resolve(self, other)
    291     # print(ret)
    292     if callable(ret): ret=ret(other)

/opt/conda/lib/python3.7/site-packages/studyPipe/studyPipe.py in _resolve(pipe, x, cls)
    251 def _resolve(pipe, x, cls=Pipe):
    252     while isinstance(pipe, Pipe__):
--> 253         pipe = pipe._____func___(x)
    254     return pipe
    255 

/opt/conda/lib/python3.7/site-packages/studyPipe/studyPipe.py in _callIfPossible(i)
    296 def callIfPossible(fn):
    297     def _callIfPossible(i):
--> 298         tt=fn(i)
    299         try:
    300             o=tt(i)

/opt/conda/lib/python3.7/site-packages/studyPipe/studyPipe.py in _resolve_function_call(x)
    124             if kwargs:
    125                 def _resolve_function_call(x):
--> 126                     resolved_func = _resolve(func, x,cls)
    127                     resolved_args = (_resolve(arg, x,cls) for arg in args)
    128                     resolved_kwargs = {k: _resolve(v, x,cls) for k, v in kwargs.items()}

/opt/conda/lib/python3.7/site-packages/studyPipe/studyPipe.py in _resolve(pipe, x, cls)
    251 def _resolve(pipe, x, cls=Pipe):
    252     while isinstance(pipe, Pipe__):
--> 253         pipe = pipe._____func___(x)
    254     return pipe
    255 

/opt/conda/lib/python3.7/site-packages/studyPipe/studyPipe.py in _curryMe(x)
    306 def curryMe(fn):
    307     def _curryMe(x):
--> 308         e=fn(x)
    309         if callable(e):
    310             return _c.curry(e)

/opt/conda/lib/python3.7/site-packages/studyPipe/studyPipe.py in _resolve_function_call(x)
    144                 def _resolve_function_call(x):
    145                     resolved_args = (_resolve(arg, x,cls) for arg in args)
--> 146                     return func(*resolved_args)
    147 
    148             return cls(_resolve_function_call,**argsCLS)

/opt/conda/lib/python3.7/site-packages/studyPipe/studyPipe.py in <genexpr>(.0)
    143             else:
    144                 def _resolve_function_call(x):
--> 145                     resolved_args = (_resolve(arg, x,cls) for arg in args)
    146                     return func(*resolved_args)
    147 

/opt/conda/lib/python3.7/site-packages/studyPipe/studyPipe.py in _resolve(pipe, x, cls)
    251 def _resolve(pipe, x, cls=Pipe):
    252     while isinstance(pipe, Pipe__):
--> 253         pipe = pipe._____func___(x)
    254     return pipe
    255 

/opt/conda/lib/python3.7/site-packages/studyPipe/studyPipe.py in _callIfPossible(i)
    296 def callIfPossible(fn):
    297     def _callIfPossible(i):
--> 298         tt=fn(i)
    299         try:
    300             o=tt(i)

/opt/conda/lib/python3.7/site-packages/studyPipe/studyPipe.py in _resolve_function_call(x)
    127                     resolved_args = (_resolve(arg, x,cls) for arg in args)
    128                     resolved_kwargs = {k: _resolve(v, x,cls) for k, v in kwargs.items()}
--> 129                     return resolved_func(*resolved_args, **resolved_kwargs)
    130             else:
    131                 def _resolve_function_call(x):

/opt/conda/lib/python3.7/site-packages/toolz/functoolz.py in __call__(self, *args, **kwargs)
    301     def __call__(self, *args, **kwargs):
    302         try:
--> 303             return self._partial(*args, **kwargs)
    304         except TypeError as exc:
    305             if self._should_curry(args, kwargs, exc):

/opt/conda/lib/python3.7/site-packages/plotly/express/_chart_types.py in line(data_frame, x, y, line_group, color, line_dash, hover_name, hover_data, custom_data, text, facet_row, facet_col, facet_col_wrap, error_x, error_x_minus, error_y, error_y_minus, animation_frame, animation_group, category_orders, labels, color_discrete_sequence, color_discrete_map, line_dash_sequence, line_dash_map, log_x, log_y, range_x, range_y, line_shape, render_mode, title, template, width, height)
    212     a polyline mark in 2D space.
    213     """
--> 214     return make_figure(args=locals(), constructor=go.Scatter)
    215 
    216 

/opt/conda/lib/python3.7/site-packages/plotly/express/_core.py in make_figure(args, constructor, trace_patch, layout_patch)
   1363 
   1364     args, trace_specs, grouped_mappings, sizeref, show_colorbar = infer_config(
-> 1365         args, constructor, trace_patch
   1366     )
   1367     grouper = [x.grouper or one_group for x in grouped_mappings] or [one_group]

/opt/conda/lib/python3.7/site-packages/plotly/express/_core.py in infer_config(args, constructor, trace_patch)
   1208             all_attrables += [group_attr]
   1209 
-> 1210     args = build_dataframe(args, all_attrables, array_attrables)
   1211     if constructor in [go.Treemap, go.Sunburst] and args["path"] is not None:
   1212         args = process_dataframe_hierarchy(args)

/opt/conda/lib/python3.7/site-packages/plotly/express/_core.py in build_dataframe(args, attrables, array_attrables)
    972                             "\n To use the index, pass it in directly as `df.index`."
    973                         )
--> 974                     raise ValueError(err_msg)
    975                 if length and len(df_input[argument]) != length:
    976                     raise ValueError(

ValueError: Value of 'y' is not the name of a column in 'data_frame'. Expected one of ['date', 'cas_confirmes', 'deces', 'reanimation', 'hospitalises', 'gueris'] but received: deces_pct_change_shift
In [359]:
graphDeathBy("France",2)

densité d'hab par region, dep ?

polution ?

temperature ?

delinquance ?

nombre de journées-lits exploitables: Nbr de places x Nbr de jours ouverts dans l'année(ex : 60 places x 365 jours = 21 900 journées théoriques)
Taux d'occupation : nombre de journées réalisée sur le nombre de journées théoriques (nombre de journées-lits exploitables) (capacité x nombre de jours d’ouverture annuel)

demain -> sae -> get "nombre de journées-lits exploitables" et "Nombre Journée")

Epidemiologie (Tech)

SEIR Model

Strategies

Ne rien Faire

Prevention - geste bariere

Confinement

Machine Learning (Tech)

Non-Supervisé

Courbe des décès

Mutations du virus

Supervisé

Courbe des décès

In [ ]:
 

Sources et Outils

In [ ]: